package com.project.core.utils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.math.NumberUtils;

/**
 * 
 * @ClassName: StringUtils
 * @Description: 字符串处理工具类
 * @author 小满
 * @date 2014年7月16日 下午1:53:59
 * 
 */
public final class StringUtils {

	public StringUtils() {
	}

	/** SQL 关键字,匹配所有字符 */
	private static final String SQL_KEYWORD_STRING = "%";
	/** SQL 关键字,匹配单个字符 */
	private static final String SQL_KEYWORD_CHAR = "_";
	/** SQL 关键字,转义符 */
	private static final String SQL_KEYWORD_ESCAPE = "\\";
	/** 默认join 分割符 */
    private static final String DEFULT_JOIN_SEPARATOR = ",";
    /** 默认封装 标示符 */
    private static final String DEFULT_WRAP_FLAG = "'";

	/**
	 * @Title: substringAfter
	 * @Description: 根据特定的标识,截取字符串,以第一个开始
	 * @param str
	 *            目标字符串
	 * @param separator
	 *            子字符串
	 * @return
	 * @return String
	 * @throws
	 */
	public static String substringAfter(String str, String separator) {
		if (contains(str, separator)) {
			return org.apache.commons.lang3.StringUtils.substringAfter(str,
					separator);
		}
		return str;
	}

	/**
	 * 截取目标字符串后面的字符串,以最后一个开始截取
	 * 
	 * @param str
	 *            待处理字符串
	 * @param separator
	 *            分隔符号
	 * @return 处理后的字符串
	 */
	public static String substringAfterLast(String str, String separator) {
		if (contains(str, separator)) {
			return org.apache.commons.lang3.StringUtils.substringAfterLast(str,
					separator);
		}
		return str;
	}

	/**
	 * 去除字符串前缀
	 * 
	 * @param str
	 *            待处理字符串
	 * @param prefix
	 *            前缀
	 * @return 处理完的字符串
	 */
	public static String removePrefix(String str, String prefix) {
		if (isNotBlank(str, prefix)) {
			if (str.startsWith(prefix)) {
				return str.substring(prefix.length());
			}
		}
		return str;
	}

	/**
	 * 添加字符串前缀
	 * 
	 * @param str
	 *            待处理字符串
	 * @param prefix
	 *            前缀
	 * @return 处理完的字符串
	 */
	public static String appendPrefix(String str, String prefix) {
		if (isNotBlank(str, prefix)) {
			if (!str.startsWith(prefix)) {
				return prefix + str;
			}
		}
		return str;
	}

	/**
	 * 去除字符串后缀
	 * 
	 * @param str
	 *            待处理字符串
	 * @param subfix
	 *            后缀
	 * @return 处理完的字符串
	 */
	public static String removeSubfix(String str, String subfix) {
		if (isNotBlank(str, subfix)) {
			if (str.endsWith(subfix)) {
				return str.substring(0, str.length() - subfix.length());
			}
		}
		return str;
	}

	/**
	 * 添加字符串后缀
	 * 
	 * @param str
	 *            待处理字符串
	 * @param subfix
	 *            后缀
	 * @return 处理完的字符串
	 */
	public static String appendSubfix(String str, String subfix) {
		if (isNotBlank(str, subfix)) {
			if (!str.endsWith(subfix)) {
				return str + subfix;
			}
		}
		return str;
	}

	/**
	 * 首字母转换成大写
	 * 
	 * @param str
	 *            待转换字符串
	 * @return 转换后字符串
	 */
	public static String capitalize(String str) {
		return org.apache.commons.lang3.StringUtils.capitalize(str);
	}

	/**
	 * 目标字符串是否包含字串
	 * 
	 * @param str
	 *            目标字符串
	 * @param searchStr
	 *            子字符串
	 * @return 目标字符串是否包含字串
	 */
	public static boolean contains(String str, String searchStr) {
		return org.apache.commons.lang3.StringUtils.contains(str, searchStr);
	}

	/**
	 * 默认字符串
	 * 
	 * 如果目标字符串为 null 返回 空串，否则返回原始字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @return 默认字符串
	 */
	public static String defaultString(String str) {
		return org.apache.commons.lang3.StringUtils.defaultString(str);
	}

	/**
	 * 默认字符串
	 * 
	 * 如果目标字符串为 null 返回 空串，否则返回原始字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @param defaultStr
	 *            默认字符串
	 * @return 默认字符串
	 */
	public static String defaultString(String str, String defaultStr) {
		return org.apache.commons.lang3.StringUtils.defaultString(str,
				defaultStr);
	}

	/**
	 * 字符串比对是否相同,
	 * 
	 * @param str
	 *            待比较字符串
	 * @param strs
	 *            待比较字符串数组 ，任何一个字符串与目标字符串匹配成功则匹配成功
	 * @return 比较结果
	 */
	public static boolean equals(String str, String... strs) {

		if (ArrayUtils.isNotEmpty(strs)) {
			for (String s : strs) {
				if (org.apache.commons.lang3.StringUtils.equals(s, str)) {
					return true;
				}
			}
			return false;
		} else {
			return null == str;
		}

	}

	/**
	 * SQL编码
	 * 
	 * <pre>
	 * 将 \ _ % 等特殊字符前补加\转意符,
	 * </pre>
	 * 
	 * @param str
	 *            未编码字符串
	 * @return 编码后字符串
	 */
	public static String escapeSql(String str) {
		if (isNotBlank(str)) {
			str = str.replace(SQL_KEYWORD_ESCAPE, SQL_KEYWORD_ESCAPE
					+ SQL_KEYWORD_ESCAPE);
			str = str.replace(SQL_KEYWORD_CHAR, SQL_KEYWORD_ESCAPE
					+ SQL_KEYWORD_CHAR);
			str = str.replace(SQL_KEYWORD_STRING, SQL_KEYWORD_ESCAPE
					+ SQL_KEYWORD_STRING);

		}
		return str;
	}

	/**
	 * 获取模糊查询字符串
	 * 
	 * <pre>
	 * 字符串前后添加 % 符号
	 * </pre>
	 * 
	 * @param str
	 *            待模糊查询字符串
	 * @return 拼接相关模糊查询标识的字符串
	 */
	public static String getFuzzyString(String str) {
		if (isNotBlank(str)) {
			str = SQL_KEYWORD_STRING + str + SQL_KEYWORD_STRING;
		}
		return str;
	}

	/**
	 * 获取模糊查询字符串,特殊字符进行转义
	 * 
	 * 
	 * <pre>
	 * 1、将 \ _ % 等特殊字符前补加\转意符,
	 * 2、字符串前后添加 % 符号
	 * </pre>
	 * 
	 * @param str
	 *            待模糊查询字符串
	 * @return 拼接相关模糊查询标识的字符串
	 */
	public static String getFuzzyStringWithEscape(String str) {
		if (isNotBlank(str)) {
			return getFuzzyString(escapeSql(str));
		}
		return null;
	}

	/**
	 * 获取被检索字符串在目标字符串中的索引的位置
	 * 
	 * @param str
	 *            目标字符串
	 * @param searchChars
	 *            被检索字符串
	 * @return 索引的位置
	 */
	public static int indexOfAny(String str, String searchChars) {
		return org.apache.commons.lang3.StringUtils.indexOfAny(str, searchChars);
	}

	/**
	 * 获取被检索字符串在目标字符串中的索引的位置
	 * 
	 * @param str
	 *            目标字符串
	 * @param searchChars
	 *            被检索字符串
	 * @return 索引的位置
	 */
	public static int indexOfAny(String str, String[] searchChars) {
		return org.apache.commons.lang3.StringUtils.indexOfAny(str, searchChars);
	}

	/**
	 * 是否为空
	 * 
	 * @param str
	 *            待校验字符串
	 * @return 是否为空
	 */
	public static boolean isBlank(String str) {
		return org.apache.commons.lang3.StringUtils.isBlank(str);
	}

	/**
	 * 判断字符串指定范围的字符是否全部是数字。
	 * 
	 * @param str
	 *            输入的字符串
	 * @param begin
	 *            起始下标，包括这个字符
	 * @param end
	 *            结束下标，不包括这个字符
	 * @return 如果范围内的字符都是数字返回true，否则返回false
	 */
	public static boolean isDigitInRange(String str, int begin, int end) {
		if (isBlank(str)) {
			return false;
		}
		if (begin < 0 || end < 0 || begin >= end) {
			return false;
		}
		if (str.length() <= end) {
			return false;
		}
		for (int i = begin; i < end; i++) {
			if (!Character.isDigit(str.charAt(i))) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 是否为空
	 * 
	 * @param str
	 *            待校验字符串
	 * @return 是否为空
	 */
	public static boolean isEmpty(String str) {
		return org.apache.commons.lang3.StringUtils.isEmpty(str);
	}

	/**
	 * 是否非空
	 * 
	 * 任何一个字符串为空,将范围false
	 * 
	 * @param strs
	 *            待校验字符串
	 * @return 是否非空
	 */
	public static boolean isNotBlank(String... strs) {
		if (null == strs) {
			return false;
		}

		for (String str : strs) {
			if (!org.apache.commons.lang3.StringUtils.isNotBlank(str)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 是否非空
	 * 
	 * 任何一个字符串为空,将范围false
	 * 
	 * @param strs
	 *            待校验字符串
	 * @return 是否非空
	 */
	public static boolean isNotEmpty(String... strs) {
		if (null == strs) {
			return false;
		}
		for (String str : strs) {
			if (!org.apache.commons.lang3.StringUtils.isNotEmpty(str)) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 是否是数字
	 * 
	 * @param str
	 *            目标字符串
	 * @return 是否是数字
	 */
	public static boolean isNumeric(String str) {
		return org.apache.commons.lang3.StringUtils.isNumeric(str);
	}

	/**
	 * 使用 , 拼接集合
	 * 
	 * @param col
	 *            待拼接集合对象
	 * @return 拼接后的字符串
	 */
	public static String join(Collection<?> col) {
		return join(col, DEFULT_JOIN_SEPARATOR);
	}

	/**
	 * 拼接集合数据
	 * 
	 * @param col
	 *            待拼接集合
	 * @param separator
	 *            分隔符
	 * @return 拼接后的集合数据
	 */
	public static String join(Collection<?> col, String separator) {
		return org.apache.commons.lang3.StringUtils.join(col, separator);
	}

	/**
	 * 拼接集合数据
	 * 
	 * @param strs
	 *            待拼接集合
	 * @param separator
	 *            分隔符
	 * @return 拼接后的集合数据
	 */
	public static String join(Object[] strs, String separator) {
		return org.apache.commons.lang3.StringUtils.join(strs, separator);
	}

	/**
	 * 左补齐字符串
	 * 
	 * @param str
	 *            待补齐字符串
	 * @param size
	 *            字符串长度
	 * @param padChar
	 *            补齐字符
	 * @return 补齐后字符串
	 */
	public static String leftPad(String str, int size, char padChar) {
		return org.apache.commons.lang3.StringUtils.leftPad(str, size, padChar);
	}

	/**
	 * 左补齐字符串
	 * 
	 * @param str
	 *            待补齐字符串
	 * @param size
	 *            字符串长度
	 * @param padStr
	 *            补齐字符
	 * @return 补齐后字符串
	 */
	public static String leftPad(String str, int size, String padStr) {
		return org.apache.commons.lang3.StringUtils.leftPad(str, size, padStr);
	}

	/**
	 * 转换成小写字母
	 * 
	 * @param str
	 *            目标字符串
	 * @return 转换成小写字母
	 */
	public static String lowerCase(String str) {
		return org.apache.commons.lang3.StringUtils.lowerCase(str);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @param separator
	 *            分隔符
	 * @return 分割后的集合数据
	 */
	public static String[] split(String str, char separator) {
		return org.apache.commons.lang3.StringUtils.split(str, separator);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @return 分割后的集合数据
	 */
	public static String[] split(String str) {
		return org.apache.commons.lang3.StringUtils.split(str);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @param separator
	 *            分隔符
	 * @return 分割后的集合数据
	 */
	public static String[] split(String str, String separator) {
		return org.apache.commons.lang3.StringUtils.split(str, separator);
	}

	/**
	 * 获取子串
	 * 
	 * @param str
	 *            目标字符串
	 * @param start
	 *            起始索引
	 * 
	 * @return 子串
	 */
	public static String substring(String str, int start) {
		return org.apache.commons.lang3.StringUtils.substring(str, start);
	}

	/**
	 * 获取子串
	 * 
	 * @param str
	 *            目标字符串
	 * @param start
	 *            起始索引
	 * @param end
	 *            结束索引
	 * 
	 * @return 子串
	 */
	public static String substring(String str, int start, int end) {
		return org.apache.commons.lang3.StringUtils.substring(str, start, end);
	}

	/**
	 * 转换成字符串
	 * 
	 * @param obj
	 *            obj
	 * @return String
	 */
	public static String toString(Object obj) {
		return obj == null ? null : obj.toString();
	}

	/**
	 * 去空格字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @return 去空格后的字符串
	 */
	public static String trim(String str) {
		return org.apache.commons.lang3.StringUtils.trim(str);
	}

	/**
	 * 去空格字符串,如果字符串为empty则返回null
	 * 
	 * @param str
	 *            目标字符串
	 * @return 去空格后的字符串
	 */
	public static String trimToNull(String str) {
		return org.apache.commons.lang3.StringUtils.trimToNull(str);
	}

	/**
	 * 去空格字符串,如果字符串为empty则返回""
	 * 
	 * @param str
	 *            目标字符串
	 * @return 去空格后的字符串
	 */
	public static String trimToEmpty(String str) {
		return org.apache.commons.lang3.StringUtils.trimToEmpty(str);
	}

	/**
	 * 转换成大写字母
	 * 
	 * @param str
	 *            目标字符串
	 * @return 转换成大写字母
	 */
	public static String upperCase(String str) {
		return org.apache.commons.lang3.StringUtils.upperCase(str);
	}

	/**
	 * 使用单引号包装字符串
	 * 
	 * 
	 * @param str
	 *            str
	 * @param flag
	 *            flag
	 * @return String
	 */
	public static String warp(String str, String flag) {
		if (isBlank(flag)) {
			flag = DEFULT_WRAP_FLAG;
		}

		StringBuilder sb = new StringBuilder();
		sb.append(flag).append(str).append(flag);
		return sb.toString();
	}

	/**
	 * 截取字符串
	 * 
	 * @param str
	 *            待截取字符串
	 * @param len
	 *            字符长度
	 * @return 截取后的字符串
	 */
	public static String left(String str, int len) {
		return org.apache.commons.lang3.StringUtils.left(str, len);
	}

	/**
	 * 字符串XML解码
	 * 
	 * @param str
	 *            待解码字符串
	 * @return 解码后字符串
	 */
	public static String unescapeXml(String str) {
		return StringEscapeUtils.unescapeXml(str);
	}

	/**
	 * 反射对象成String类型
	 * 
	 * @param obj
	 *            对象
	 * @return 反射后的字符串
	 */
	public static String reflectionToString(Object obj) {
		return ToStringBuilder.reflectionToString(obj);
	}

	/**
	 * 分割字符串
	 * 
	 * @param str
	 *            目标字符串
	 * @param separator
	 *            分隔符
	 * @return 分割后的集合数据
	 */
	public static List<Long> splitToLongList(String str, String separator) {
		List<Long> list = new ArrayList<Long>();

		if (isNotEmpty(str)) {
			String[] strs = split(str, separator);
			for (String s : strs) {
				list.add(NumberUtils.toLong(s));
			}
		}
		return list;
	}
	
	/**
     * Object转换成Long
     *
     * @param obj
     * @return
     */
    public static Long getLong(Object obj) {
        return getLong(obj, 0L);
    }
    
    /**
     * Object转换成Long
     *
     * @param obj
     * @return
     */
    public static Long getLong(Object obj, Long defaultValue) {
        try {
            return Long.valueOf(obj + "");
        } catch (Exception e) {
            return defaultValue;
        }
    }

}
